package com.dc.gameserver.serverCore.model.dbsql.modelVo;

import java.util.ArrayList;
import java.util.List;

public class TRoleEquExample {
    protected String orderByClause;

    protected boolean distinct;

    protected List<Criteria> oredCriteria;

    protected Integer limitStart;

    protected Integer limitEnd;

    public TRoleEquExample() {
        oredCriteria = new ArrayList<Criteria>();
    }

    public void setOrderByClause(String orderByClause) {
        this.orderByClause = orderByClause;
    }

    public String getOrderByClause() {
        return orderByClause;
    }

    public void setDistinct(boolean distinct) {
        this.distinct = distinct;
    }

    public boolean isDistinct() {
        return distinct;
    }

    public List<Criteria> getOredCriteria() {
        return oredCriteria;
    }

    public void or(Criteria criteria) {
        oredCriteria.add(criteria);
    }

    public Criteria or() {
        Criteria criteria = createCriteriaInternal();
        oredCriteria.add(criteria);
        return criteria;
    }

    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();
        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }
        return criteria;
    }

    protected Criteria createCriteriaInternal() {
        Criteria criteria = new Criteria();
        return criteria;
    }

    public void clear() {
        oredCriteria.clear();
        orderByClause = null;
        distinct = false;
    }

    public void setLimitStart(Integer limitStart) {
        this.limitStart=limitStart;
    }

    public Integer getLimitStart() {
        return limitStart;
    }

    public void setLimitEnd(Integer limitEnd) {
        this.limitEnd=limitEnd;
    }

    public Integer getLimitEnd() {
        return limitEnd;
    }

    protected abstract static class GeneratedCriteria {
        protected List<Criterion> criteria;

        protected GeneratedCriteria() {
            super();
            criteria = new ArrayList<Criterion>();
        }

        public boolean isValid() {
            return criteria.size() > 0;
        }

        public List<Criterion> getAllCriteria() {
            return criteria;
        }

        public List<Criterion> getCriteria() {
            return criteria;
        }

        protected void addCriterion(String condition) {
            if (condition == null) {
                throw new RuntimeException("Value for condition cannot be null");
            }
            criteria.add(new Criterion(condition));
        }

        protected void addCriterion(String condition, Object value, String property) {
            if (value == null) {
                throw new RuntimeException("Value for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value));
        }

        protected void addCriterion(String condition, Object value1, Object value2, String property) {
            if (value1 == null || value2 == null) {
                throw new RuntimeException("Between values for " + property + " cannot be null");
            }
            criteria.add(new Criterion(condition, value1, value2));
        }

        public Criteria andEquidIsNull() {
            addCriterion("EQUID is null");
            return (Criteria) this;
        }

        public Criteria andEquidIsNotNull() {
            addCriterion("EQUID is not null");
            return (Criteria) this;
        }

        public Criteria andEquidEqualTo(Integer value) {
            addCriterion("EQUID =", value, "equid");
            return (Criteria) this;
        }

        public Criteria andEquidNotEqualTo(Integer value) {
            addCriterion("EQUID <>", value, "equid");
            return (Criteria) this;
        }

        public Criteria andEquidGreaterThan(Integer value) {
            addCriterion("EQUID >", value, "equid");
            return (Criteria) this;
        }

        public Criteria andEquidGreaterThanOrEqualTo(Integer value) {
            addCriterion("EQUID >=", value, "equid");
            return (Criteria) this;
        }

        public Criteria andEquidLessThan(Integer value) {
            addCriterion("EQUID <", value, "equid");
            return (Criteria) this;
        }

        public Criteria andEquidLessThanOrEqualTo(Integer value) {
            addCriterion("EQUID <=", value, "equid");
            return (Criteria) this;
        }

        public Criteria andEquidIn(List<Integer> values) {
            addCriterion("EQUID in", values, "equid");
            return (Criteria) this;
        }

        public Criteria andEquidNotIn(List<Integer> values) {
            addCriterion("EQUID not in", values, "equid");
            return (Criteria) this;
        }

        public Criteria andEquidBetween(Integer value1, Integer value2) {
            addCriterion("EQUID between", value1, value2, "equid");
            return (Criteria) this;
        }

        public Criteria andEquidNotBetween(Integer value1, Integer value2) {
            addCriterion("EQUID not between", value1, value2, "equid");
            return (Criteria) this;
        }

        public Criteria andEqutypeidIsNull() {
            addCriterion("EQUTYPEID is null");
            return (Criteria) this;
        }

        public Criteria andEqutypeidIsNotNull() {
            addCriterion("EQUTYPEID is not null");
            return (Criteria) this;
        }

        public Criteria andEqutypeidEqualTo(Integer value) {
            addCriterion("EQUTYPEID =", value, "equtypeid");
            return (Criteria) this;
        }

        public Criteria andEqutypeidNotEqualTo(Integer value) {
            addCriterion("EQUTYPEID <>", value, "equtypeid");
            return (Criteria) this;
        }

        public Criteria andEqutypeidGreaterThan(Integer value) {
            addCriterion("EQUTYPEID >", value, "equtypeid");
            return (Criteria) this;
        }

        public Criteria andEqutypeidGreaterThanOrEqualTo(Integer value) {
            addCriterion("EQUTYPEID >=", value, "equtypeid");
            return (Criteria) this;
        }

        public Criteria andEqutypeidLessThan(Integer value) {
            addCriterion("EQUTYPEID <", value, "equtypeid");
            return (Criteria) this;
        }

        public Criteria andEqutypeidLessThanOrEqualTo(Integer value) {
            addCriterion("EQUTYPEID <=", value, "equtypeid");
            return (Criteria) this;
        }

        public Criteria andEqutypeidIn(List<Integer> values) {
            addCriterion("EQUTYPEID in", values, "equtypeid");
            return (Criteria) this;
        }

        public Criteria andEqutypeidNotIn(List<Integer> values) {
            addCriterion("EQUTYPEID not in", values, "equtypeid");
            return (Criteria) this;
        }

        public Criteria andEqutypeidBetween(Integer value1, Integer value2) {
            addCriterion("EQUTYPEID between", value1, value2, "equtypeid");
            return (Criteria) this;
        }

        public Criteria andEqutypeidNotBetween(Integer value1, Integer value2) {
            addCriterion("EQUTYPEID not between", value1, value2, "equtypeid");
            return (Criteria) this;
        }

        public Criteria andItemtypeIsNull() {
            addCriterion("ITEMTYPE is null");
            return (Criteria) this;
        }

        public Criteria andItemtypeIsNotNull() {
            addCriterion("ITEMTYPE is not null");
            return (Criteria) this;
        }

        public Criteria andItemtypeEqualTo(Byte value) {
            addCriterion("ITEMTYPE =", value, "itemtype");
            return (Criteria) this;
        }

        public Criteria andItemtypeNotEqualTo(Byte value) {
            addCriterion("ITEMTYPE <>", value, "itemtype");
            return (Criteria) this;
        }

        public Criteria andItemtypeGreaterThan(Byte value) {
            addCriterion("ITEMTYPE >", value, "itemtype");
            return (Criteria) this;
        }

        public Criteria andItemtypeGreaterThanOrEqualTo(Byte value) {
            addCriterion("ITEMTYPE >=", value, "itemtype");
            return (Criteria) this;
        }

        public Criteria andItemtypeLessThan(Byte value) {
            addCriterion("ITEMTYPE <", value, "itemtype");
            return (Criteria) this;
        }

        public Criteria andItemtypeLessThanOrEqualTo(Byte value) {
            addCriterion("ITEMTYPE <=", value, "itemtype");
            return (Criteria) this;
        }

        public Criteria andItemtypeIn(List<Byte> values) {
            addCriterion("ITEMTYPE in", values, "itemtype");
            return (Criteria) this;
        }

        public Criteria andItemtypeNotIn(List<Byte> values) {
            addCriterion("ITEMTYPE not in", values, "itemtype");
            return (Criteria) this;
        }

        public Criteria andItemtypeBetween(Byte value1, Byte value2) {
            addCriterion("ITEMTYPE between", value1, value2, "itemtype");
            return (Criteria) this;
        }

        public Criteria andItemtypeNotBetween(Byte value1, Byte value2) {
            addCriterion("ITEMTYPE not between", value1, value2, "itemtype");
            return (Criteria) this;
        }

        public Criteria andOwneridIsNull() {
            addCriterion("OWNERID is null");
            return (Criteria) this;
        }

        public Criteria andOwneridIsNotNull() {
            addCriterion("OWNERID is not null");
            return (Criteria) this;
        }

        public Criteria andOwneridEqualTo(Integer value) {
            addCriterion("OWNERID =", value, "ownerid");
            return (Criteria) this;
        }

        public Criteria andOwneridNotEqualTo(Integer value) {
            addCriterion("OWNERID <>", value, "ownerid");
            return (Criteria) this;
        }

        public Criteria andOwneridGreaterThan(Integer value) {
            addCriterion("OWNERID >", value, "ownerid");
            return (Criteria) this;
        }

        public Criteria andOwneridGreaterThanOrEqualTo(Integer value) {
            addCriterion("OWNERID >=", value, "ownerid");
            return (Criteria) this;
        }

        public Criteria andOwneridLessThan(Integer value) {
            addCriterion("OWNERID <", value, "ownerid");
            return (Criteria) this;
        }

        public Criteria andOwneridLessThanOrEqualTo(Integer value) {
            addCriterion("OWNERID <=", value, "ownerid");
            return (Criteria) this;
        }

        public Criteria andOwneridIn(List<Integer> values) {
            addCriterion("OWNERID in", values, "ownerid");
            return (Criteria) this;
        }

        public Criteria andOwneridNotIn(List<Integer> values) {
            addCriterion("OWNERID not in", values, "ownerid");
            return (Criteria) this;
        }

        public Criteria andOwneridBetween(Integer value1, Integer value2) {
            addCriterion("OWNERID between", value1, value2, "ownerid");
            return (Criteria) this;
        }

        public Criteria andOwneridNotBetween(Integer value1, Integer value2) {
            addCriterion("OWNERID not between", value1, value2, "ownerid");
            return (Criteria) this;
        }

        public Criteria andEqupinzhiIsNull() {
            addCriterion("EQUPINZHI is null");
            return (Criteria) this;
        }

        public Criteria andEqupinzhiIsNotNull() {
            addCriterion("EQUPINZHI is not null");
            return (Criteria) this;
        }

        public Criteria andEqupinzhiEqualTo(Byte value) {
            addCriterion("EQUPINZHI =", value, "equpinzhi");
            return (Criteria) this;
        }

        public Criteria andEqupinzhiNotEqualTo(Byte value) {
            addCriterion("EQUPINZHI <>", value, "equpinzhi");
            return (Criteria) this;
        }

        public Criteria andEqupinzhiGreaterThan(Byte value) {
            addCriterion("EQUPINZHI >", value, "equpinzhi");
            return (Criteria) this;
        }

        public Criteria andEqupinzhiGreaterThanOrEqualTo(Byte value) {
            addCriterion("EQUPINZHI >=", value, "equpinzhi");
            return (Criteria) this;
        }

        public Criteria andEqupinzhiLessThan(Byte value) {
            addCriterion("EQUPINZHI <", value, "equpinzhi");
            return (Criteria) this;
        }

        public Criteria andEqupinzhiLessThanOrEqualTo(Byte value) {
            addCriterion("EQUPINZHI <=", value, "equpinzhi");
            return (Criteria) this;
        }

        public Criteria andEqupinzhiIn(List<Byte> values) {
            addCriterion("EQUPINZHI in", values, "equpinzhi");
            return (Criteria) this;
        }

        public Criteria andEqupinzhiNotIn(List<Byte> values) {
            addCriterion("EQUPINZHI not in", values, "equpinzhi");
            return (Criteria) this;
        }

        public Criteria andEqupinzhiBetween(Byte value1, Byte value2) {
            addCriterion("EQUPINZHI between", value1, value2, "equpinzhi");
            return (Criteria) this;
        }

        public Criteria andEqupinzhiNotBetween(Byte value1, Byte value2) {
            addCriterion("EQUPINZHI not between", value1, value2, "equpinzhi");
            return (Criteria) this;
        }

        public Criteria andEqupinjieIsNull() {
            addCriterion("EQUPINJIE is null");
            return (Criteria) this;
        }

        public Criteria andEqupinjieIsNotNull() {
            addCriterion("EQUPINJIE is not null");
            return (Criteria) this;
        }

        public Criteria andEqupinjieEqualTo(Byte value) {
            addCriterion("EQUPINJIE =", value, "equpinjie");
            return (Criteria) this;
        }

        public Criteria andEqupinjieNotEqualTo(Byte value) {
            addCriterion("EQUPINJIE <>", value, "equpinjie");
            return (Criteria) this;
        }

        public Criteria andEqupinjieGreaterThan(Byte value) {
            addCriterion("EQUPINJIE >", value, "equpinjie");
            return (Criteria) this;
        }

        public Criteria andEqupinjieGreaterThanOrEqualTo(Byte value) {
            addCriterion("EQUPINJIE >=", value, "equpinjie");
            return (Criteria) this;
        }

        public Criteria andEqupinjieLessThan(Byte value) {
            addCriterion("EQUPINJIE <", value, "equpinjie");
            return (Criteria) this;
        }

        public Criteria andEqupinjieLessThanOrEqualTo(Byte value) {
            addCriterion("EQUPINJIE <=", value, "equpinjie");
            return (Criteria) this;
        }

        public Criteria andEqupinjieIn(List<Byte> values) {
            addCriterion("EQUPINJIE in", values, "equpinjie");
            return (Criteria) this;
        }

        public Criteria andEqupinjieNotIn(List<Byte> values) {
            addCriterion("EQUPINJIE not in", values, "equpinjie");
            return (Criteria) this;
        }

        public Criteria andEqupinjieBetween(Byte value1, Byte value2) {
            addCriterion("EQUPINJIE between", value1, value2, "equpinjie");
            return (Criteria) this;
        }

        public Criteria andEqupinjieNotBetween(Byte value1, Byte value2) {
            addCriterion("EQUPINJIE not between", value1, value2, "equpinjie");
            return (Criteria) this;
        }

        public Criteria andEqupinjieexpIsNull() {
            addCriterion("EQUPINJIEEXP is null");
            return (Criteria) this;
        }

        public Criteria andEqupinjieexpIsNotNull() {
            addCriterion("EQUPINJIEEXP is not null");
            return (Criteria) this;
        }

        public Criteria andEqupinjieexpEqualTo(Integer value) {
            addCriterion("EQUPINJIEEXP =", value, "equpinjieexp");
            return (Criteria) this;
        }

        public Criteria andEqupinjieexpNotEqualTo(Integer value) {
            addCriterion("EQUPINJIEEXP <>", value, "equpinjieexp");
            return (Criteria) this;
        }

        public Criteria andEqupinjieexpGreaterThan(Integer value) {
            addCriterion("EQUPINJIEEXP >", value, "equpinjieexp");
            return (Criteria) this;
        }

        public Criteria andEqupinjieexpGreaterThanOrEqualTo(Integer value) {
            addCriterion("EQUPINJIEEXP >=", value, "equpinjieexp");
            return (Criteria) this;
        }

        public Criteria andEqupinjieexpLessThan(Integer value) {
            addCriterion("EQUPINJIEEXP <", value, "equpinjieexp");
            return (Criteria) this;
        }

        public Criteria andEqupinjieexpLessThanOrEqualTo(Integer value) {
            addCriterion("EQUPINJIEEXP <=", value, "equpinjieexp");
            return (Criteria) this;
        }

        public Criteria andEqupinjieexpIn(List<Integer> values) {
            addCriterion("EQUPINJIEEXP in", values, "equpinjieexp");
            return (Criteria) this;
        }

        public Criteria andEqupinjieexpNotIn(List<Integer> values) {
            addCriterion("EQUPINJIEEXP not in", values, "equpinjieexp");
            return (Criteria) this;
        }

        public Criteria andEqupinjieexpBetween(Integer value1, Integer value2) {
            addCriterion("EQUPINJIEEXP between", value1, value2, "equpinjieexp");
            return (Criteria) this;
        }

        public Criteria andEqupinjieexpNotBetween(Integer value1, Integer value2) {
            addCriterion("EQUPINJIEEXP not between", value1, value2, "equpinjieexp");
            return (Criteria) this;
        }

        public Criteria andEqulevelIsNull() {
            addCriterion("EQULEVEL is null");
            return (Criteria) this;
        }

        public Criteria andEqulevelIsNotNull() {
            addCriterion("EQULEVEL is not null");
            return (Criteria) this;
        }

        public Criteria andEqulevelEqualTo(Integer value) {
            addCriterion("EQULEVEL =", value, "equlevel");
            return (Criteria) this;
        }

        public Criteria andEqulevelNotEqualTo(Integer value) {
            addCriterion("EQULEVEL <>", value, "equlevel");
            return (Criteria) this;
        }

        public Criteria andEqulevelGreaterThan(Integer value) {
            addCriterion("EQULEVEL >", value, "equlevel");
            return (Criteria) this;
        }

        public Criteria andEqulevelGreaterThanOrEqualTo(Integer value) {
            addCriterion("EQULEVEL >=", value, "equlevel");
            return (Criteria) this;
        }

        public Criteria andEqulevelLessThan(Integer value) {
            addCriterion("EQULEVEL <", value, "equlevel");
            return (Criteria) this;
        }

        public Criteria andEqulevelLessThanOrEqualTo(Integer value) {
            addCriterion("EQULEVEL <=", value, "equlevel");
            return (Criteria) this;
        }

        public Criteria andEqulevelIn(List<Integer> values) {
            addCriterion("EQULEVEL in", values, "equlevel");
            return (Criteria) this;
        }

        public Criteria andEqulevelNotIn(List<Integer> values) {
            addCriterion("EQULEVEL not in", values, "equlevel");
            return (Criteria) this;
        }

        public Criteria andEqulevelBetween(Integer value1, Integer value2) {
            addCriterion("EQULEVEL between", value1, value2, "equlevel");
            return (Criteria) this;
        }

        public Criteria andEqulevelNotBetween(Integer value1, Integer value2) {
            addCriterion("EQULEVEL not between", value1, value2, "equlevel");
            return (Criteria) this;
        }

        public Criteria andEqutypeIsNull() {
            addCriterion("EQUTYPE is null");
            return (Criteria) this;
        }

        public Criteria andEqutypeIsNotNull() {
            addCriterion("EQUTYPE is not null");
            return (Criteria) this;
        }

        public Criteria andEqutypeEqualTo(Byte value) {
            addCriterion("EQUTYPE =", value, "equtype");
            return (Criteria) this;
        }

        public Criteria andEqutypeNotEqualTo(Byte value) {
            addCriterion("EQUTYPE <>", value, "equtype");
            return (Criteria) this;
        }

        public Criteria andEqutypeGreaterThan(Byte value) {
            addCriterion("EQUTYPE >", value, "equtype");
            return (Criteria) this;
        }

        public Criteria andEqutypeGreaterThanOrEqualTo(Byte value) {
            addCriterion("EQUTYPE >=", value, "equtype");
            return (Criteria) this;
        }

        public Criteria andEqutypeLessThan(Byte value) {
            addCriterion("EQUTYPE <", value, "equtype");
            return (Criteria) this;
        }

        public Criteria andEqutypeLessThanOrEqualTo(Byte value) {
            addCriterion("EQUTYPE <=", value, "equtype");
            return (Criteria) this;
        }

        public Criteria andEqutypeIn(List<Byte> values) {
            addCriterion("EQUTYPE in", values, "equtype");
            return (Criteria) this;
        }

        public Criteria andEqutypeNotIn(List<Byte> values) {
            addCriterion("EQUTYPE not in", values, "equtype");
            return (Criteria) this;
        }

        public Criteria andEqutypeBetween(Byte value1, Byte value2) {
            addCriterion("EQUTYPE between", value1, value2, "equtype");
            return (Criteria) this;
        }

        public Criteria andEqutypeNotBetween(Byte value1, Byte value2) {
            addCriterion("EQUTYPE not between", value1, value2, "equtype");
            return (Criteria) this;
        }

        public Criteria andEqulocationIsNull() {
            addCriterion("EQULOCATION is null");
            return (Criteria) this;
        }

        public Criteria andEqulocationIsNotNull() {
            addCriterion("EQULOCATION is not null");
            return (Criteria) this;
        }

        public Criteria andEqulocationEqualTo(Byte value) {
            addCriterion("EQULOCATION =", value, "equlocation");
            return (Criteria) this;
        }

        public Criteria andEqulocationNotEqualTo(Byte value) {
            addCriterion("EQULOCATION <>", value, "equlocation");
            return (Criteria) this;
        }

        public Criteria andEqulocationGreaterThan(Byte value) {
            addCriterion("EQULOCATION >", value, "equlocation");
            return (Criteria) this;
        }

        public Criteria andEqulocationGreaterThanOrEqualTo(Byte value) {
            addCriterion("EQULOCATION >=", value, "equlocation");
            return (Criteria) this;
        }

        public Criteria andEqulocationLessThan(Byte value) {
            addCriterion("EQULOCATION <", value, "equlocation");
            return (Criteria) this;
        }

        public Criteria andEqulocationLessThanOrEqualTo(Byte value) {
            addCriterion("EQULOCATION <=", value, "equlocation");
            return (Criteria) this;
        }

        public Criteria andEqulocationIn(List<Byte> values) {
            addCriterion("EQULOCATION in", values, "equlocation");
            return (Criteria) this;
        }

        public Criteria andEqulocationNotIn(List<Byte> values) {
            addCriterion("EQULOCATION not in", values, "equlocation");
            return (Criteria) this;
        }

        public Criteria andEqulocationBetween(Byte value1, Byte value2) {
            addCriterion("EQULOCATION between", value1, value2, "equlocation");
            return (Criteria) this;
        }

        public Criteria andEqulocationNotBetween(Byte value1, Byte value2) {
            addCriterion("EQULOCATION not between", value1, value2, "equlocation");
            return (Criteria) this;
        }

        public Criteria andEqutimeoutIsNull() {
            addCriterion("EQUTIMEOUT is null");
            return (Criteria) this;
        }

        public Criteria andEqutimeoutIsNotNull() {
            addCriterion("EQUTIMEOUT is not null");
            return (Criteria) this;
        }

        public Criteria andEqutimeoutEqualTo(Long value) {
            addCriterion("EQUTIMEOUT =", value, "equtimeout");
            return (Criteria) this;
        }

        public Criteria andEqutimeoutNotEqualTo(Long value) {
            addCriterion("EQUTIMEOUT <>", value, "equtimeout");
            return (Criteria) this;
        }

        public Criteria andEqutimeoutGreaterThan(Long value) {
            addCriterion("EQUTIMEOUT >", value, "equtimeout");
            return (Criteria) this;
        }

        public Criteria andEqutimeoutGreaterThanOrEqualTo(Long value) {
            addCriterion("EQUTIMEOUT >=", value, "equtimeout");
            return (Criteria) this;
        }

        public Criteria andEqutimeoutLessThan(Long value) {
            addCriterion("EQUTIMEOUT <", value, "equtimeout");
            return (Criteria) this;
        }

        public Criteria andEqutimeoutLessThanOrEqualTo(Long value) {
            addCriterion("EQUTIMEOUT <=", value, "equtimeout");
            return (Criteria) this;
        }

        public Criteria andEqutimeoutIn(List<Long> values) {
            addCriterion("EQUTIMEOUT in", values, "equtimeout");
            return (Criteria) this;
        }

        public Criteria andEqutimeoutNotIn(List<Long> values) {
            addCriterion("EQUTIMEOUT not in", values, "equtimeout");
            return (Criteria) this;
        }

        public Criteria andEqutimeoutBetween(Long value1, Long value2) {
            addCriterion("EQUTIMEOUT between", value1, value2, "equtimeout");
            return (Criteria) this;
        }

        public Criteria andEqutimeoutNotBetween(Long value1, Long value2) {
            addCriterion("EQUTIMEOUT not between", value1, value2, "equtimeout");
            return (Criteria) this;
        }

        public Criteria andEqupriceIsNull() {
            addCriterion("EQUPRICE is null");
            return (Criteria) this;
        }

        public Criteria andEqupriceIsNotNull() {
            addCriterion("EQUPRICE is not null");
            return (Criteria) this;
        }

        public Criteria andEqupriceEqualTo(Integer value) {
            addCriterion("EQUPRICE =", value, "equprice");
            return (Criteria) this;
        }

        public Criteria andEqupriceNotEqualTo(Integer value) {
            addCriterion("EQUPRICE <>", value, "equprice");
            return (Criteria) this;
        }

        public Criteria andEqupriceGreaterThan(Integer value) {
            addCriterion("EQUPRICE >", value, "equprice");
            return (Criteria) this;
        }

        public Criteria andEqupriceGreaterThanOrEqualTo(Integer value) {
            addCriterion("EQUPRICE >=", value, "equprice");
            return (Criteria) this;
        }

        public Criteria andEqupriceLessThan(Integer value) {
            addCriterion("EQUPRICE <", value, "equprice");
            return (Criteria) this;
        }

        public Criteria andEqupriceLessThanOrEqualTo(Integer value) {
            addCriterion("EQUPRICE <=", value, "equprice");
            return (Criteria) this;
        }

        public Criteria andEqupriceIn(List<Integer> values) {
            addCriterion("EQUPRICE in", values, "equprice");
            return (Criteria) this;
        }

        public Criteria andEqupriceNotIn(List<Integer> values) {
            addCriterion("EQUPRICE not in", values, "equprice");
            return (Criteria) this;
        }

        public Criteria andEqupriceBetween(Integer value1, Integer value2) {
            addCriterion("EQUPRICE between", value1, value2, "equprice");
            return (Criteria) this;
        }

        public Criteria andEqupriceNotBetween(Integer value1, Integer value2) {
            addCriterion("EQUPRICE not between", value1, value2, "equprice");
            return (Criteria) this;
        }

        public Criteria andEqushowbagIsNull() {
            addCriterion("EQUSHOWBAG is null");
            return (Criteria) this;
        }

        public Criteria andEqushowbagIsNotNull() {
            addCriterion("EQUSHOWBAG is not null");
            return (Criteria) this;
        }

        public Criteria andEqushowbagEqualTo(Boolean value) {
            addCriterion("EQUSHOWBAG =", value, "equshowbag");
            return (Criteria) this;
        }

        public Criteria andEqushowbagNotEqualTo(Boolean value) {
            addCriterion("EQUSHOWBAG <>", value, "equshowbag");
            return (Criteria) this;
        }

        public Criteria andEqushowbagGreaterThan(Boolean value) {
            addCriterion("EQUSHOWBAG >", value, "equshowbag");
            return (Criteria) this;
        }

        public Criteria andEqushowbagGreaterThanOrEqualTo(Boolean value) {
            addCriterion("EQUSHOWBAG >=", value, "equshowbag");
            return (Criteria) this;
        }

        public Criteria andEqushowbagLessThan(Boolean value) {
            addCriterion("EQUSHOWBAG <", value, "equshowbag");
            return (Criteria) this;
        }

        public Criteria andEqushowbagLessThanOrEqualTo(Boolean value) {
            addCriterion("EQUSHOWBAG <=", value, "equshowbag");
            return (Criteria) this;
        }

        public Criteria andEqushowbagIn(List<Boolean> values) {
            addCriterion("EQUSHOWBAG in", values, "equshowbag");
            return (Criteria) this;
        }

        public Criteria andEqushowbagNotIn(List<Boolean> values) {
            addCriterion("EQUSHOWBAG not in", values, "equshowbag");
            return (Criteria) this;
        }

        public Criteria andEqushowbagBetween(Boolean value1, Boolean value2) {
            addCriterion("EQUSHOWBAG between", value1, value2, "equshowbag");
            return (Criteria) this;
        }

        public Criteria andEqushowbagNotBetween(Boolean value1, Boolean value2) {
            addCriterion("EQUSHOWBAG not between", value1, value2, "equshowbag");
            return (Criteria) this;
        }

        public Criteria andEffectnum1IsNull() {
            addCriterion("EFFECTNUM1 is null");
            return (Criteria) this;
        }

        public Criteria andEffectnum1IsNotNull() {
            addCriterion("EFFECTNUM1 is not null");
            return (Criteria) this;
        }

        public Criteria andEffectnum1EqualTo(Double value) {
            addCriterion("EFFECTNUM1 =", value, "effectnum1");
            return (Criteria) this;
        }

        public Criteria andEffectnum1NotEqualTo(Double value) {
            addCriterion("EFFECTNUM1 <>", value, "effectnum1");
            return (Criteria) this;
        }

        public Criteria andEffectnum1GreaterThan(Double value) {
            addCriterion("EFFECTNUM1 >", value, "effectnum1");
            return (Criteria) this;
        }

        public Criteria andEffectnum1GreaterThanOrEqualTo(Double value) {
            addCriterion("EFFECTNUM1 >=", value, "effectnum1");
            return (Criteria) this;
        }

        public Criteria andEffectnum1LessThan(Double value) {
            addCriterion("EFFECTNUM1 <", value, "effectnum1");
            return (Criteria) this;
        }

        public Criteria andEffectnum1LessThanOrEqualTo(Double value) {
            addCriterion("EFFECTNUM1 <=", value, "effectnum1");
            return (Criteria) this;
        }

        public Criteria andEffectnum1In(List<Double> values) {
            addCriterion("EFFECTNUM1 in", values, "effectnum1");
            return (Criteria) this;
        }

        public Criteria andEffectnum1NotIn(List<Double> values) {
            addCriterion("EFFECTNUM1 not in", values, "effectnum1");
            return (Criteria) this;
        }

        public Criteria andEffectnum1Between(Double value1, Double value2) {
            addCriterion("EFFECTNUM1 between", value1, value2, "effectnum1");
            return (Criteria) this;
        }

        public Criteria andEffectnum1NotBetween(Double value1, Double value2) {
            addCriterion("EFFECTNUM1 not between", value1, value2, "effectnum1");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup1IsNull() {
            addCriterion("EFFECTNUMGROWUP1 is null");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup1IsNotNull() {
            addCriterion("EFFECTNUMGROWUP1 is not null");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup1EqualTo(Double value) {
            addCriterion("EFFECTNUMGROWUP1 =", value, "effectnumgrowup1");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup1NotEqualTo(Double value) {
            addCriterion("EFFECTNUMGROWUP1 <>", value, "effectnumgrowup1");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup1GreaterThan(Double value) {
            addCriterion("EFFECTNUMGROWUP1 >", value, "effectnumgrowup1");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup1GreaterThanOrEqualTo(Double value) {
            addCriterion("EFFECTNUMGROWUP1 >=", value, "effectnumgrowup1");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup1LessThan(Double value) {
            addCriterion("EFFECTNUMGROWUP1 <", value, "effectnumgrowup1");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup1LessThanOrEqualTo(Double value) {
            addCriterion("EFFECTNUMGROWUP1 <=", value, "effectnumgrowup1");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup1In(List<Double> values) {
            addCriterion("EFFECTNUMGROWUP1 in", values, "effectnumgrowup1");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup1NotIn(List<Double> values) {
            addCriterion("EFFECTNUMGROWUP1 not in", values, "effectnumgrowup1");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup1Between(Double value1, Double value2) {
            addCriterion("EFFECTNUMGROWUP1 between", value1, value2, "effectnumgrowup1");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup1NotBetween(Double value1, Double value2) {
            addCriterion("EFFECTNUMGROWUP1 not between", value1, value2, "effectnumgrowup1");
            return (Criteria) this;
        }

        public Criteria andEffectnum2IsNull() {
            addCriterion("EFFECTNUM2 is null");
            return (Criteria) this;
        }

        public Criteria andEffectnum2IsNotNull() {
            addCriterion("EFFECTNUM2 is not null");
            return (Criteria) this;
        }

        public Criteria andEffectnum2EqualTo(Double value) {
            addCriterion("EFFECTNUM2 =", value, "effectnum2");
            return (Criteria) this;
        }

        public Criteria andEffectnum2NotEqualTo(Double value) {
            addCriterion("EFFECTNUM2 <>", value, "effectnum2");
            return (Criteria) this;
        }

        public Criteria andEffectnum2GreaterThan(Double value) {
            addCriterion("EFFECTNUM2 >", value, "effectnum2");
            return (Criteria) this;
        }

        public Criteria andEffectnum2GreaterThanOrEqualTo(Double value) {
            addCriterion("EFFECTNUM2 >=", value, "effectnum2");
            return (Criteria) this;
        }

        public Criteria andEffectnum2LessThan(Double value) {
            addCriterion("EFFECTNUM2 <", value, "effectnum2");
            return (Criteria) this;
        }

        public Criteria andEffectnum2LessThanOrEqualTo(Double value) {
            addCriterion("EFFECTNUM2 <=", value, "effectnum2");
            return (Criteria) this;
        }

        public Criteria andEffectnum2In(List<Double> values) {
            addCriterion("EFFECTNUM2 in", values, "effectnum2");
            return (Criteria) this;
        }

        public Criteria andEffectnum2NotIn(List<Double> values) {
            addCriterion("EFFECTNUM2 not in", values, "effectnum2");
            return (Criteria) this;
        }

        public Criteria andEffectnum2Between(Double value1, Double value2) {
            addCriterion("EFFECTNUM2 between", value1, value2, "effectnum2");
            return (Criteria) this;
        }

        public Criteria andEffectnum2NotBetween(Double value1, Double value2) {
            addCriterion("EFFECTNUM2 not between", value1, value2, "effectnum2");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup2IsNull() {
            addCriterion("EFFECTNUMGROWUP2 is null");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup2IsNotNull() {
            addCriterion("EFFECTNUMGROWUP2 is not null");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup2EqualTo(Double value) {
            addCriterion("EFFECTNUMGROWUP2 =", value, "effectnumgrowup2");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup2NotEqualTo(Double value) {
            addCriterion("EFFECTNUMGROWUP2 <>", value, "effectnumgrowup2");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup2GreaterThan(Double value) {
            addCriterion("EFFECTNUMGROWUP2 >", value, "effectnumgrowup2");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup2GreaterThanOrEqualTo(Double value) {
            addCriterion("EFFECTNUMGROWUP2 >=", value, "effectnumgrowup2");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup2LessThan(Double value) {
            addCriterion("EFFECTNUMGROWUP2 <", value, "effectnumgrowup2");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup2LessThanOrEqualTo(Double value) {
            addCriterion("EFFECTNUMGROWUP2 <=", value, "effectnumgrowup2");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup2In(List<Double> values) {
            addCriterion("EFFECTNUMGROWUP2 in", values, "effectnumgrowup2");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup2NotIn(List<Double> values) {
            addCriterion("EFFECTNUMGROWUP2 not in", values, "effectnumgrowup2");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup2Between(Double value1, Double value2) {
            addCriterion("EFFECTNUMGROWUP2 between", value1, value2, "effectnumgrowup2");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup2NotBetween(Double value1, Double value2) {
            addCriterion("EFFECTNUMGROWUP2 not between", value1, value2, "effectnumgrowup2");
            return (Criteria) this;
        }

        public Criteria andEffectnum3IsNull() {
            addCriterion("EFFECTNUM3 is null");
            return (Criteria) this;
        }

        public Criteria andEffectnum3IsNotNull() {
            addCriterion("EFFECTNUM3 is not null");
            return (Criteria) this;
        }

        public Criteria andEffectnum3EqualTo(Double value) {
            addCriterion("EFFECTNUM3 =", value, "effectnum3");
            return (Criteria) this;
        }

        public Criteria andEffectnum3NotEqualTo(Double value) {
            addCriterion("EFFECTNUM3 <>", value, "effectnum3");
            return (Criteria) this;
        }

        public Criteria andEffectnum3GreaterThan(Double value) {
            addCriterion("EFFECTNUM3 >", value, "effectnum3");
            return (Criteria) this;
        }

        public Criteria andEffectnum3GreaterThanOrEqualTo(Double value) {
            addCriterion("EFFECTNUM3 >=", value, "effectnum3");
            return (Criteria) this;
        }

        public Criteria andEffectnum3LessThan(Double value) {
            addCriterion("EFFECTNUM3 <", value, "effectnum3");
            return (Criteria) this;
        }

        public Criteria andEffectnum3LessThanOrEqualTo(Double value) {
            addCriterion("EFFECTNUM3 <=", value, "effectnum3");
            return (Criteria) this;
        }

        public Criteria andEffectnum3In(List<Double> values) {
            addCriterion("EFFECTNUM3 in", values, "effectnum3");
            return (Criteria) this;
        }

        public Criteria andEffectnum3NotIn(List<Double> values) {
            addCriterion("EFFECTNUM3 not in", values, "effectnum3");
            return (Criteria) this;
        }

        public Criteria andEffectnum3Between(Double value1, Double value2) {
            addCriterion("EFFECTNUM3 between", value1, value2, "effectnum3");
            return (Criteria) this;
        }

        public Criteria andEffectnum3NotBetween(Double value1, Double value2) {
            addCriterion("EFFECTNUM3 not between", value1, value2, "effectnum3");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup3IsNull() {
            addCriterion("EFFECTNUMGROWUP3 is null");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup3IsNotNull() {
            addCriterion("EFFECTNUMGROWUP3 is not null");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup3EqualTo(Double value) {
            addCriterion("EFFECTNUMGROWUP3 =", value, "effectnumgrowup3");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup3NotEqualTo(Double value) {
            addCriterion("EFFECTNUMGROWUP3 <>", value, "effectnumgrowup3");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup3GreaterThan(Double value) {
            addCriterion("EFFECTNUMGROWUP3 >", value, "effectnumgrowup3");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup3GreaterThanOrEqualTo(Double value) {
            addCriterion("EFFECTNUMGROWUP3 >=", value, "effectnumgrowup3");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup3LessThan(Double value) {
            addCriterion("EFFECTNUMGROWUP3 <", value, "effectnumgrowup3");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup3LessThanOrEqualTo(Double value) {
            addCriterion("EFFECTNUMGROWUP3 <=", value, "effectnumgrowup3");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup3In(List<Double> values) {
            addCriterion("EFFECTNUMGROWUP3 in", values, "effectnumgrowup3");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup3NotIn(List<Double> values) {
            addCriterion("EFFECTNUMGROWUP3 not in", values, "effectnumgrowup3");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup3Between(Double value1, Double value2) {
            addCriterion("EFFECTNUMGROWUP3 between", value1, value2, "effectnumgrowup3");
            return (Criteria) this;
        }

        public Criteria andEffectnumgrowup3NotBetween(Double value1, Double value2) {
            addCriterion("EFFECTNUMGROWUP3 not between", value1, value2, "effectnumgrowup3");
            return (Criteria) this;
        }
    }

    public static class Criteria extends GeneratedCriteria {

        protected Criteria() {
            super();
        }
    }

    public static class Criterion {
        private String condition;

        private Object value;

        private Object secondValue;

        private boolean noValue;

        private boolean singleValue;

        private boolean betweenValue;

        private boolean listValue;

        private String typeHandler;

        public String getCondition() {
            return condition;
        }

        public Object getValue() {
            return value;
        }

        public Object getSecondValue() {
            return secondValue;
        }

        public boolean isNoValue() {
            return noValue;
        }

        public boolean isSingleValue() {
            return singleValue;
        }

        public boolean isBetweenValue() {
            return betweenValue;
        }

        public boolean isListValue() {
            return listValue;
        }

        public String getTypeHandler() {
            return typeHandler;
        }

        protected Criterion(String condition) {
            super();
            this.condition = condition;
            this.typeHandler = null;
            this.noValue = true;
        }

        protected Criterion(String condition, Object value, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.typeHandler = typeHandler;
            if (value instanceof List<?>) {
                this.listValue = true;
            } else {
                this.singleValue = true;
            }
        }

        protected Criterion(String condition, Object value) {
            this(condition, value, null);
        }

        protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
            super();
            this.condition = condition;
            this.value = value;
            this.secondValue = secondValue;
            this.typeHandler = typeHandler;
            this.betweenValue = true;
        }

        protected Criterion(String condition, Object value, Object secondValue) {
            this(condition, value, secondValue, null);
        }
    }
}